// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g 2010-02-11 14:47:17

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;

using Antlr.Runtime.Tree;

public partial class ExprParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"NEGATE", 
		"CONDITION", 
		"SEPARATOR", 
		"IDENT", 
		"ASSIGN", 
		"WS", 
		"AND", 
		"OR", 
		"EQUALS", 
		"NOTEQUALS", 
		"LT", 
		"LTEQ", 
		"GT", 
		"GTEQ", 
		"PLUS", 
		"MINUS", 
		"MULTIPLY", 
		"DIVIDE", 
		"MODULO", 
		"POWER", 
		"NOT", 
		"NUMBER", 
		"CHAR", 
		"EscapeSequence", 
		"UnicodeEscape", 
		"HexDigit", 
		"'?'", 
		"':'", 
		"'('", 
		"')'"
    };

    public const int MODULO = 22;
    public const int LT = 14;
    public const int NUMBER = 25;
    public const int LTEQ = 15;
    public const int CHAR = 26;
    public const int POWER = 23;
    public const int NEGATE = 4;
    public const int NOTEQUALS = 13;
    public const int CONDITION = 5;
    public const int EQUALS = 12;
    public const int SEPARATOR = 6;
    public const int NOT = 24;
    public const int MINUS = 19;
    public const int GTEQ = 17;
    public const int AND = 10;
    public const int EOF = -1;
    public const int HexDigit = 29;
    public const int T__30 = 30;
    public const int T__31 = 31;
    public const int T__32 = 32;
    public const int T__33 = 33;
    public const int WS = 9;
    public const int MULTIPLY = 20;
    public const int UnicodeEscape = 28;
    public const int OR = 11;
    public const int ASSIGN = 8;
    public const int GT = 16;
    public const int IDENT = 7;
    public const int PLUS = 18;
    public const int EscapeSequence = 27;
    public const int DIVIDE = 21;

    // delegates
    // delegators



        public ExprParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public ExprParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return ExprParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g"; }
    }


    public class prog_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "prog"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:14:1: prog : ( stat )* ;
    public ExprParser.prog_return prog() // throws RecognitionException [1]
    {   
        ExprParser.prog_return retval = new ExprParser.prog_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        ExprParser.stat_return stat1 = default(ExprParser.stat_return);



        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:14:5: ( ( stat )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:14:7: ( stat )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:14:7: ( stat )*
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == IDENT || LA1_0 == WS || LA1_0 == MINUS || (LA1_0 >= NOT && LA1_0 <= CHAR) || LA1_0 == 32) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:14:9: stat
            			    {
            			    	PushFollow(FOLLOW_stat_in_prog53);
            			    	stat1 = stat();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, stat1.Tree);

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "prog"

    public class stat_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "stat"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:16:1: stat : ( expr SEPARATOR -> expr | IDENT ASSIGN expr SEPARATOR -> ^( ASSIGN IDENT expr ) | WS ->);
    public ExprParser.stat_return stat() // throws RecognitionException [1]
    {   
        ExprParser.stat_return retval = new ExprParser.stat_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken SEPARATOR3 = null;
        IToken IDENT4 = null;
        IToken ASSIGN5 = null;
        IToken SEPARATOR7 = null;
        IToken WS8 = null;
        ExprParser.expr_return expr2 = default(ExprParser.expr_return);

        ExprParser.expr_return expr6 = default(ExprParser.expr_return);


        CommonTree SEPARATOR3_tree=null;
        CommonTree IDENT4_tree=null;
        CommonTree ASSIGN5_tree=null;
        CommonTree SEPARATOR7_tree=null;
        CommonTree WS8_tree=null;
        RewriteRuleTokenStream stream_IDENT = new RewriteRuleTokenStream(adaptor,"token IDENT");
        RewriteRuleTokenStream stream_WS = new RewriteRuleTokenStream(adaptor,"token WS");
        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_expr = new RewriteRuleSubtreeStream(adaptor,"rule expr");
        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:16:5: ( expr SEPARATOR -> expr | IDENT ASSIGN expr SEPARATOR -> ^( ASSIGN IDENT expr ) | WS ->)
            int alt2 = 3;
            switch ( input.LA(1) ) 
            {
            case MINUS:
            case NOT:
            case NUMBER:
            case CHAR:
            case 32:
            	{
                alt2 = 1;
                }
                break;
            case IDENT:
            	{
                int LA2_2 = input.LA(2);

                if ( (LA2_2 == ASSIGN) )
                {
                    alt2 = 2;
                }
                else if ( (LA2_2 == SEPARATOR || (LA2_2 >= AND && LA2_2 <= POWER) || LA2_2 == 30) )
                {
                    alt2 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d2s2 =
                        new NoViableAltException("", 2, 2, input);

                    throw nvae_d2s2;
                }
                }
                break;
            case WS:
            	{
                alt2 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            }

            switch (alt2) 
            {
                case 1 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:16:7: expr SEPARATOR
                    {
                    	PushFollow(FOLLOW_expr_in_stat65);
                    	expr2 = expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expr.Add(expr2.Tree);
                    	SEPARATOR3=(IToken)Match(input,SEPARATOR,FOLLOW_SEPARATOR_in_stat67); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_SEPARATOR.Add(SEPARATOR3);



                    	// AST REWRITE
                    	// elements:          expr
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 16:25: -> expr
                    	{
                    	    adaptor.AddChild(root_0, stream_expr.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:17:4: IDENT ASSIGN expr SEPARATOR
                    {
                    	IDENT4=(IToken)Match(input,IDENT,FOLLOW_IDENT_in_stat79); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_IDENT.Add(IDENT4);

                    	ASSIGN5=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_stat81); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN5);

                    	PushFollow(FOLLOW_expr_in_stat83);
                    	expr6 = expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expr.Add(expr6.Tree);
                    	SEPARATOR7=(IToken)Match(input,SEPARATOR,FOLLOW_SEPARATOR_in_stat85); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_SEPARATOR.Add(SEPARATOR7);



                    	// AST REWRITE
                    	// elements:          ASSIGN, IDENT, expr
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 17:32: -> ^( ASSIGN IDENT expr )
                    	{
                    	    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:17:35: ^( ASSIGN IDENT expr )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_IDENT.NextNode());
                    	    adaptor.AddChild(root_1, stream_expr.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:18:4: WS
                    {
                    	WS8=(IToken)Match(input,WS,FOLLOW_WS_in_stat100); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_WS.Add(WS8);



                    	// AST REWRITE
                    	// elements:          
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 18:13: ->
                    	{
                    	    root_0 = null;
                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "stat"

    public class expr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "expr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:21:1: expr : conditionalExpr ;
    public ExprParser.expr_return expr() // throws RecognitionException [1]
    {   
        ExprParser.expr_return retval = new ExprParser.expr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        ExprParser.conditionalExpr_return conditionalExpr9 = default(ExprParser.conditionalExpr_return);



        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:21:5: ( conditionalExpr )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:21:7: conditionalExpr
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_conditionalExpr_in_expr117);
            	conditionalExpr9 = conditionalExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditionalExpr9.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "expr"

    public class conditionalExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "conditionalExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:24:1: conditionalExpr options {backtrack=true; } : ( booleanExpr '?' booleanExpr ':' booleanExpr -> ( ^( CONDITION booleanExpr booleanExpr booleanExpr ) )? | booleanExpr );
    public ExprParser.conditionalExpr_return conditionalExpr() // throws RecognitionException [1]
    {   
        ExprParser.conditionalExpr_return retval = new ExprParser.conditionalExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal11 = null;
        IToken char_literal13 = null;
        ExprParser.booleanExpr_return booleanExpr10 = default(ExprParser.booleanExpr_return);

        ExprParser.booleanExpr_return booleanExpr12 = default(ExprParser.booleanExpr_return);

        ExprParser.booleanExpr_return booleanExpr14 = default(ExprParser.booleanExpr_return);

        ExprParser.booleanExpr_return booleanExpr15 = default(ExprParser.booleanExpr_return);


        CommonTree char_literal11_tree=null;
        CommonTree char_literal13_tree=null;
        RewriteRuleTokenStream stream_30 = new RewriteRuleTokenStream(adaptor,"token 30");
        RewriteRuleTokenStream stream_31 = new RewriteRuleTokenStream(adaptor,"token 31");
        RewriteRuleSubtreeStream stream_booleanExpr = new RewriteRuleSubtreeStream(adaptor,"rule booleanExpr");
        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:2: ( booleanExpr '?' booleanExpr ':' booleanExpr -> ( ^( CONDITION booleanExpr booleanExpr booleanExpr ) )? | booleanExpr )
            int alt3 = 2;
            switch ( input.LA(1) ) 
            {
            case 32:
            	{
                int LA3_1 = input.LA(2);

                if ( (synpred1_Expr()) )
                {
                    alt3 = 1;
                }
                else if ( (true) )
                {
                    alt3 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d3s1 =
                        new NoViableAltException("", 3, 1, input);

                    throw nvae_d3s1;
                }
                }
                break;
            case IDENT:
            case NUMBER:
            case CHAR:
            	{
                int LA3_2 = input.LA(2);

                if ( (synpred1_Expr()) )
                {
                    alt3 = 1;
                }
                else if ( (true) )
                {
                    alt3 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d3s2 =
                        new NoViableAltException("", 3, 2, input);

                    throw nvae_d3s2;
                }
                }
                break;
            case MINUS:
            	{
                int LA3_3 = input.LA(2);

                if ( (synpred1_Expr()) )
                {
                    alt3 = 1;
                }
                else if ( (true) )
                {
                    alt3 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d3s3 =
                        new NoViableAltException("", 3, 3, input);

                    throw nvae_d3s3;
                }
                }
                break;
            case NOT:
            	{
                int LA3_4 = input.LA(2);

                if ( (synpred1_Expr()) )
                {
                    alt3 = 1;
                }
                else if ( (true) )
                {
                    alt3 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d3s4 =
                        new NoViableAltException("", 3, 4, input);

                    throw nvae_d3s4;
                }
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d3s0 =
            	        new NoViableAltException("", 3, 0, input);

            	    throw nvae_d3s0;
            }

            switch (alt3) 
            {
                case 1 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:4: booleanExpr '?' booleanExpr ':' booleanExpr
                    {
                    	PushFollow(FOLLOW_booleanExpr_in_conditionalExpr140);
                    	booleanExpr10 = booleanExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_booleanExpr.Add(booleanExpr10.Tree);
                    	char_literal11=(IToken)Match(input,30,FOLLOW_30_in_conditionalExpr142); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_30.Add(char_literal11);

                    	PushFollow(FOLLOW_booleanExpr_in_conditionalExpr144);
                    	booleanExpr12 = booleanExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_booleanExpr.Add(booleanExpr12.Tree);
                    	char_literal13=(IToken)Match(input,31,FOLLOW_31_in_conditionalExpr146); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_31.Add(char_literal13);

                    	PushFollow(FOLLOW_booleanExpr_in_conditionalExpr148);
                    	booleanExpr14 = booleanExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_booleanExpr.Add(booleanExpr14.Tree);


                    	// AST REWRITE
                    	// elements:          booleanExpr, booleanExpr, booleanExpr
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 25:48: -> ( ^( CONDITION booleanExpr booleanExpr booleanExpr ) )?
                    	{
                    	    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:51: ( ^( CONDITION booleanExpr booleanExpr booleanExpr ) )?
                    	    if ( stream_booleanExpr.HasNext() || stream_booleanExpr.HasNext() || stream_booleanExpr.HasNext() )
                    	    {
                    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:51: ^( CONDITION booleanExpr booleanExpr booleanExpr )
                    	        {
                    	        CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	        root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(CONDITION, "CONDITION"), root_1);

                    	        adaptor.AddChild(root_1, stream_booleanExpr.NextTree());
                    	        adaptor.AddChild(root_1, stream_booleanExpr.NextTree());
                    	        adaptor.AddChild(root_1, stream_booleanExpr.NextTree());

                    	        adaptor.AddChild(root_0, root_1);
                    	        }

                    	    }
                    	    stream_booleanExpr.Reset();
                    	    stream_booleanExpr.Reset();
                    	    stream_booleanExpr.Reset();

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:26:4: booleanExpr
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_booleanExpr_in_conditionalExpr166);
                    	booleanExpr15 = booleanExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, booleanExpr15.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "conditionalExpr"

    public class booleanExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "booleanExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:29:1: booleanExpr : equalityExpr ( ( AND | OR ) equalityExpr )* ;
    public ExprParser.booleanExpr_return booleanExpr() // throws RecognitionException [1]
    {   
        ExprParser.booleanExpr_return retval = new ExprParser.booleanExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken AND17 = null;
        IToken OR18 = null;
        ExprParser.equalityExpr_return equalityExpr16 = default(ExprParser.equalityExpr_return);

        ExprParser.equalityExpr_return equalityExpr19 = default(ExprParser.equalityExpr_return);


        CommonTree AND17_tree=null;
        CommonTree OR18_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:2: ( equalityExpr ( ( AND | OR ) equalityExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:4: equalityExpr ( ( AND | OR ) equalityExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_equalityExpr_in_booleanExpr177);
            	equalityExpr16 = equalityExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equalityExpr16.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:17: ( ( AND | OR ) equalityExpr )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( ((LA5_0 >= AND && LA5_0 <= OR)) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:18: ( AND | OR ) equalityExpr
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:18: ( AND | OR )
            			    	int alt4 = 2;
            			    	int LA4_0 = input.LA(1);

            			    	if ( (LA4_0 == AND) )
            			    	{
            			    	    alt4 = 1;
            			    	}
            			    	else if ( (LA4_0 == OR) )
            			    	{
            			    	    alt4 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d4s0 =
            			    	        new NoViableAltException("", 4, 0, input);

            			    	    throw nvae_d4s0;
            			    	}
            			    	switch (alt4) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:19: AND
            			    	        {
            			    	        	AND17=(IToken)Match(input,AND,FOLLOW_AND_in_booleanExpr181); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{AND17_tree = (CommonTree)adaptor.Create(AND17);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(AND17_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:30:26: OR
            			    	        {
            			    	        	OR18=(IToken)Match(input,OR,FOLLOW_OR_in_booleanExpr186); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{OR18_tree = (CommonTree)adaptor.Create(OR18);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(OR18_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_equalityExpr_in_booleanExpr190);
            			    	equalityExpr19 = equalityExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equalityExpr19.Tree);

            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "booleanExpr"

    public class equalityExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "equalityExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:33:1: equalityExpr : relationalExpr ( ( EQUALS | NOTEQUALS ) relationalExpr )* ;
    public ExprParser.equalityExpr_return equalityExpr() // throws RecognitionException [1]
    {   
        ExprParser.equalityExpr_return retval = new ExprParser.equalityExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken EQUALS21 = null;
        IToken NOTEQUALS22 = null;
        ExprParser.relationalExpr_return relationalExpr20 = default(ExprParser.relationalExpr_return);

        ExprParser.relationalExpr_return relationalExpr23 = default(ExprParser.relationalExpr_return);


        CommonTree EQUALS21_tree=null;
        CommonTree NOTEQUALS22_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:2: ( relationalExpr ( ( EQUALS | NOTEQUALS ) relationalExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:4: relationalExpr ( ( EQUALS | NOTEQUALS ) relationalExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_relationalExpr_in_equalityExpr204);
            	relationalExpr20 = relationalExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relationalExpr20.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:19: ( ( EQUALS | NOTEQUALS ) relationalExpr )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( ((LA7_0 >= EQUALS && LA7_0 <= NOTEQUALS)) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:20: ( EQUALS | NOTEQUALS ) relationalExpr
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:20: ( EQUALS | NOTEQUALS )
            			    	int alt6 = 2;
            			    	int LA6_0 = input.LA(1);

            			    	if ( (LA6_0 == EQUALS) )
            			    	{
            			    	    alt6 = 1;
            			    	}
            			    	else if ( (LA6_0 == NOTEQUALS) )
            			    	{
            			    	    alt6 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d6s0 =
            			    	        new NoViableAltException("", 6, 0, input);

            			    	    throw nvae_d6s0;
            			    	}
            			    	switch (alt6) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:21: EQUALS
            			    	        {
            			    	        	EQUALS21=(IToken)Match(input,EQUALS,FOLLOW_EQUALS_in_equalityExpr208); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{EQUALS21_tree = (CommonTree)adaptor.Create(EQUALS21);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(EQUALS21_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:34:31: NOTEQUALS
            			    	        {
            			    	        	NOTEQUALS22=(IToken)Match(input,NOTEQUALS,FOLLOW_NOTEQUALS_in_equalityExpr213); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{NOTEQUALS22_tree = (CommonTree)adaptor.Create(NOTEQUALS22);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(NOTEQUALS22_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_relationalExpr_in_equalityExpr217);
            			    	relationalExpr23 = relationalExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relationalExpr23.Tree);

            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "equalityExpr"

    public class relationalExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "relationalExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:37:1: relationalExpr : addExpr ( ( LT | LTEQ | GT | GTEQ ) addExpr )* ;
    public ExprParser.relationalExpr_return relationalExpr() // throws RecognitionException [1]
    {   
        ExprParser.relationalExpr_return retval = new ExprParser.relationalExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken LT25 = null;
        IToken LTEQ26 = null;
        IToken GT27 = null;
        IToken GTEQ28 = null;
        ExprParser.addExpr_return addExpr24 = default(ExprParser.addExpr_return);

        ExprParser.addExpr_return addExpr29 = default(ExprParser.addExpr_return);


        CommonTree LT25_tree=null;
        CommonTree LTEQ26_tree=null;
        CommonTree GT27_tree=null;
        CommonTree GTEQ28_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:2: ( addExpr ( ( LT | LTEQ | GT | GTEQ ) addExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:4: addExpr ( ( LT | LTEQ | GT | GTEQ ) addExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_addExpr_in_relationalExpr231);
            	addExpr24 = addExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, addExpr24.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:12: ( ( LT | LTEQ | GT | GTEQ ) addExpr )*
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);

            	    if ( ((LA9_0 >= LT && LA9_0 <= GTEQ)) )
            	    {
            	        alt9 = 1;
            	    }


            	    switch (alt9) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:13: ( LT | LTEQ | GT | GTEQ ) addExpr
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:13: ( LT | LTEQ | GT | GTEQ )
            			    	int alt8 = 4;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case LT:
            			    		{
            			    	    alt8 = 1;
            			    	    }
            			    	    break;
            			    	case LTEQ:
            			    		{
            			    	    alt8 = 2;
            			    	    }
            			    	    break;
            			    	case GT:
            			    		{
            			    	    alt8 = 3;
            			    	    }
            			    	    break;
            			    	case GTEQ:
            			    		{
            			    	    alt8 = 4;
            			    	    }
            			    	    break;
            			    		default:
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    NoViableAltException nvae_d8s0 =
            			    		        new NoViableAltException("", 8, 0, input);

            			    		    throw nvae_d8s0;
            			    	}

            			    	switch (alt8) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:14: LT
            			    	        {
            			    	        	LT25=(IToken)Match(input,LT,FOLLOW_LT_in_relationalExpr235); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{LT25_tree = (CommonTree)adaptor.Create(LT25);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(LT25_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:20: LTEQ
            			    	        {
            			    	        	LTEQ26=(IToken)Match(input,LTEQ,FOLLOW_LTEQ_in_relationalExpr240); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{LTEQ26_tree = (CommonTree)adaptor.Create(LTEQ26);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(LTEQ26_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:28: GT
            			    	        {
            			    	        	GT27=(IToken)Match(input,GT,FOLLOW_GT_in_relationalExpr245); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{GT27_tree = (CommonTree)adaptor.Create(GT27);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(GT27_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 4 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:38:34: GTEQ
            			    	        {
            			    	        	GTEQ28=(IToken)Match(input,GTEQ,FOLLOW_GTEQ_in_relationalExpr250); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{GTEQ28_tree = (CommonTree)adaptor.Create(GTEQ28);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(GTEQ28_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_addExpr_in_relationalExpr254);
            			    	addExpr29 = addExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, addExpr29.Tree);

            			    }
            			    break;

            			default:
            			    goto loop9;
            	    }
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whining that label 'loop9' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "relationalExpr"

    public class addExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "addExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:41:1: addExpr : multExpr ( ( PLUS | MINUS ) multExpr )* ;
    public ExprParser.addExpr_return addExpr() // throws RecognitionException [1]
    {   
        ExprParser.addExpr_return retval = new ExprParser.addExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken PLUS31 = null;
        IToken MINUS32 = null;
        ExprParser.multExpr_return multExpr30 = default(ExprParser.multExpr_return);

        ExprParser.multExpr_return multExpr33 = default(ExprParser.multExpr_return);


        CommonTree PLUS31_tree=null;
        CommonTree MINUS32_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:2: ( multExpr ( ( PLUS | MINUS ) multExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:4: multExpr ( ( PLUS | MINUS ) multExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_multExpr_in_addExpr268);
            	multExpr30 = multExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multExpr30.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:13: ( ( PLUS | MINUS ) multExpr )*
            	do 
            	{
            	    int alt11 = 2;
            	    int LA11_0 = input.LA(1);

            	    if ( ((LA11_0 >= PLUS && LA11_0 <= MINUS)) )
            	    {
            	        alt11 = 1;
            	    }


            	    switch (alt11) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:14: ( PLUS | MINUS ) multExpr
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:14: ( PLUS | MINUS )
            			    	int alt10 = 2;
            			    	int LA10_0 = input.LA(1);

            			    	if ( (LA10_0 == PLUS) )
            			    	{
            			    	    alt10 = 1;
            			    	}
            			    	else if ( (LA10_0 == MINUS) )
            			    	{
            			    	    alt10 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d10s0 =
            			    	        new NoViableAltException("", 10, 0, input);

            			    	    throw nvae_d10s0;
            			    	}
            			    	switch (alt10) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:15: PLUS
            			    	        {
            			    	        	PLUS31=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_addExpr272); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{PLUS31_tree = (CommonTree)adaptor.Create(PLUS31);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(PLUS31_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:42:23: MINUS
            			    	        {
            			    	        	MINUS32=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_addExpr277); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{MINUS32_tree = (CommonTree)adaptor.Create(MINUS32);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(MINUS32_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_multExpr_in_addExpr281);
            			    	multExpr33 = multExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multExpr33.Tree);

            			    }
            			    break;

            			default:
            			    goto loop11;
            	    }
            	} while (true);

            	loop11:
            		;	// Stops C# compiler whining that label 'loop11' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "addExpr"

    public class multExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "multExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:45:1: multExpr : powerExpr ( ( MULTIPLY | DIVIDE | MODULO ) powerExpr )* ;
    public ExprParser.multExpr_return multExpr() // throws RecognitionException [1]
    {   
        ExprParser.multExpr_return retval = new ExprParser.multExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken MULTIPLY35 = null;
        IToken DIVIDE36 = null;
        IToken MODULO37 = null;
        ExprParser.powerExpr_return powerExpr34 = default(ExprParser.powerExpr_return);

        ExprParser.powerExpr_return powerExpr38 = default(ExprParser.powerExpr_return);


        CommonTree MULTIPLY35_tree=null;
        CommonTree DIVIDE36_tree=null;
        CommonTree MODULO37_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:2: ( powerExpr ( ( MULTIPLY | DIVIDE | MODULO ) powerExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:4: powerExpr ( ( MULTIPLY | DIVIDE | MODULO ) powerExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_powerExpr_in_multExpr295);
            	powerExpr34 = powerExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, powerExpr34.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:14: ( ( MULTIPLY | DIVIDE | MODULO ) powerExpr )*
            	do 
            	{
            	    int alt13 = 2;
            	    int LA13_0 = input.LA(1);

            	    if ( ((LA13_0 >= MULTIPLY && LA13_0 <= MODULO)) )
            	    {
            	        alt13 = 1;
            	    }


            	    switch (alt13) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:15: ( MULTIPLY | DIVIDE | MODULO ) powerExpr
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:15: ( MULTIPLY | DIVIDE | MODULO )
            			    	int alt12 = 3;
            			    	switch ( input.LA(1) ) 
            			    	{
            			    	case MULTIPLY:
            			    		{
            			    	    alt12 = 1;
            			    	    }
            			    	    break;
            			    	case DIVIDE:
            			    		{
            			    	    alt12 = 2;
            			    	    }
            			    	    break;
            			    	case MODULO:
            			    		{
            			    	    alt12 = 3;
            			    	    }
            			    	    break;
            			    		default:
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    NoViableAltException nvae_d12s0 =
            			    		        new NoViableAltException("", 12, 0, input);

            			    		    throw nvae_d12s0;
            			    	}

            			    	switch (alt12) 
            			    	{
            			    	    case 1 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:16: MULTIPLY
            			    	        {
            			    	        	MULTIPLY35=(IToken)Match(input,MULTIPLY,FOLLOW_MULTIPLY_in_multExpr299); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{MULTIPLY35_tree = (CommonTree)adaptor.Create(MULTIPLY35);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(MULTIPLY35_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:28: DIVIDE
            			    	        {
            			    	        	DIVIDE36=(IToken)Match(input,DIVIDE,FOLLOW_DIVIDE_in_multExpr304); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{DIVIDE36_tree = (CommonTree)adaptor.Create(DIVIDE36);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(DIVIDE36_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 3 :
            			    	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:46:38: MODULO
            			    	        {
            			    	        	MODULO37=(IToken)Match(input,MODULO,FOLLOW_MODULO_in_multExpr309); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{MODULO37_tree = (CommonTree)adaptor.Create(MODULO37);
            			    	        		root_0 = (CommonTree)adaptor.BecomeRoot(MODULO37_tree, root_0);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_powerExpr_in_multExpr313);
            			    	powerExpr38 = powerExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, powerExpr38.Tree);

            			    }
            			    break;

            			default:
            			    goto loop13;
            	    }
            	} while (true);

            	loop13:
            		;	// Stops C# compiler whining that label 'loop13' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "multExpr"

    public class powerExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "powerExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:49:1: powerExpr : unaryExpr ( POWER unaryExpr )* ;
    public ExprParser.powerExpr_return powerExpr() // throws RecognitionException [1]
    {   
        ExprParser.powerExpr_return retval = new ExprParser.powerExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken POWER40 = null;
        ExprParser.unaryExpr_return unaryExpr39 = default(ExprParser.unaryExpr_return);

        ExprParser.unaryExpr_return unaryExpr41 = default(ExprParser.unaryExpr_return);


        CommonTree POWER40_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:50:2: ( unaryExpr ( POWER unaryExpr )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:50:4: unaryExpr ( POWER unaryExpr )*
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_unaryExpr_in_powerExpr327);
            	unaryExpr39 = unaryExpr();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unaryExpr39.Tree);
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:50:14: ( POWER unaryExpr )*
            	do 
            	{
            	    int alt14 = 2;
            	    int LA14_0 = input.LA(1);

            	    if ( (LA14_0 == POWER) )
            	    {
            	        alt14 = 1;
            	    }


            	    switch (alt14) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:50:15: POWER unaryExpr
            			    {
            			    	POWER40=(IToken)Match(input,POWER,FOLLOW_POWER_in_powerExpr330); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{POWER40_tree = (CommonTree)adaptor.Create(POWER40);
            			    		root_0 = (CommonTree)adaptor.BecomeRoot(POWER40_tree, root_0);
            			    	}
            			    	PushFollow(FOLLOW_unaryExpr_in_powerExpr333);
            			    	unaryExpr41 = unaryExpr();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unaryExpr41.Tree);

            			    }
            			    break;

            			default:
            			    goto loop14;
            	    }
            	} while (true);

            	loop14:
            		;	// Stops C# compiler whining that label 'loop14' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "powerExpr"

    public class unaryExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "unaryExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:53:1: unaryExpr : ( primaryExpr | MINUS primaryExpr -> ^( NEGATE primaryExpr ) | NOT primaryExpr );
    public ExprParser.unaryExpr_return unaryExpr() // throws RecognitionException [1]
    {   
        ExprParser.unaryExpr_return retval = new ExprParser.unaryExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken MINUS43 = null;
        IToken NOT45 = null;
        ExprParser.primaryExpr_return primaryExpr42 = default(ExprParser.primaryExpr_return);

        ExprParser.primaryExpr_return primaryExpr44 = default(ExprParser.primaryExpr_return);

        ExprParser.primaryExpr_return primaryExpr46 = default(ExprParser.primaryExpr_return);


        CommonTree MINUS43_tree=null;
        CommonTree NOT45_tree=null;
        RewriteRuleTokenStream stream_MINUS = new RewriteRuleTokenStream(adaptor,"token MINUS");
        RewriteRuleSubtreeStream stream_primaryExpr = new RewriteRuleSubtreeStream(adaptor,"rule primaryExpr");
        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:54:2: ( primaryExpr | MINUS primaryExpr -> ^( NEGATE primaryExpr ) | NOT primaryExpr )
            int alt15 = 3;
            switch ( input.LA(1) ) 
            {
            case IDENT:
            case NUMBER:
            case CHAR:
            case 32:
            	{
                alt15 = 1;
                }
                break;
            case MINUS:
            	{
                alt15 = 2;
                }
                break;
            case NOT:
            	{
                alt15 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d15s0 =
            	        new NoViableAltException("", 15, 0, input);

            	    throw nvae_d15s0;
            }

            switch (alt15) 
            {
                case 1 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:54:4: primaryExpr
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primaryExpr_in_unaryExpr347);
                    	primaryExpr42 = primaryExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primaryExpr42.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:55:4: MINUS primaryExpr
                    {
                    	MINUS43=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_unaryExpr352); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_MINUS.Add(MINUS43);

                    	PushFollow(FOLLOW_primaryExpr_in_unaryExpr354);
                    	primaryExpr44 = primaryExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primaryExpr.Add(primaryExpr44.Tree);


                    	// AST REWRITE
                    	// elements:          primaryExpr
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (CommonTree)adaptor.GetNilNode();
                    	// 55:22: -> ^( NEGATE primaryExpr )
                    	{
                    	    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:55:25: ^( NEGATE primaryExpr )
                    	    {
                    	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
                    	    root_1 = (CommonTree)adaptor.BecomeRoot((CommonTree)adaptor.Create(NEGATE, "NEGATE"), root_1);

                    	    adaptor.AddChild(root_1, stream_primaryExpr.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:56:4: NOT primaryExpr
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	NOT45=(IToken)Match(input,NOT,FOLLOW_NOT_in_unaryExpr367); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{NOT45_tree = (CommonTree)adaptor.Create(NOT45);
                    		root_0 = (CommonTree)adaptor.BecomeRoot(NOT45_tree, root_0);
                    	}
                    	PushFollow(FOLLOW_primaryExpr_in_unaryExpr370);
                    	primaryExpr46 = primaryExpr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primaryExpr46.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "unaryExpr"

    public class primaryExpr_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "primaryExpr"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:59:1: primaryExpr : ( '(' expr ')' | value );
    public ExprParser.primaryExpr_return primaryExpr() // throws RecognitionException [1]
    {   
        ExprParser.primaryExpr_return retval = new ExprParser.primaryExpr_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal47 = null;
        IToken char_literal49 = null;
        ExprParser.expr_return expr48 = default(ExprParser.expr_return);

        ExprParser.value_return value50 = default(ExprParser.value_return);


        CommonTree char_literal47_tree=null;
        CommonTree char_literal49_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:60:2: ( '(' expr ')' | value )
            int alt16 = 2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0 == 32) )
            {
                alt16 = 1;
            }
            else if ( (LA16_0 == IDENT || (LA16_0 >= NUMBER && LA16_0 <= CHAR)) )
            {
                alt16 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d16s0 =
                    new NoViableAltException("", 16, 0, input);

                throw nvae_d16s0;
            }
            switch (alt16) 
            {
                case 1 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:60:4: '(' expr ')'
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	char_literal47=(IToken)Match(input,32,FOLLOW_32_in_primaryExpr381); if (state.failed) return retval;
                    	PushFollow(FOLLOW_expr_in_primaryExpr384);
                    	expr48 = expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expr48.Tree);
                    	char_literal49=(IToken)Match(input,33,FOLLOW_33_in_primaryExpr386); if (state.failed) return retval;

                    }
                    break;
                case 2 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:61:4: value
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_value_in_primaryExpr392);
                    	value50 = value();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, value50.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "primaryExpr"

    public class value_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "value"
    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:64:1: value : ( NUMBER | IDENT | CHAR );
    public ExprParser.value_return value() // throws RecognitionException [1]
    {   
        ExprParser.value_return retval = new ExprParser.value_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken set51 = null;

        CommonTree set51_tree=null;

        try 
    	{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:65:2: ( NUMBER | IDENT | CHAR )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	set51 = (IToken)input.LT(1);
            	if ( input.LA(1) == IDENT || (input.LA(1) >= NUMBER && input.LA(1) <= CHAR) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (CommonTree)adaptor.Create(set51));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "value"

    // $ANTLR start "synpred1_Expr"
    public void synpred1_Expr_fragment() {
        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:4: ( booleanExpr '?' booleanExpr ':' booleanExpr )
        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:25:4: booleanExpr '?' booleanExpr ':' booleanExpr
        {
        	PushFollow(FOLLOW_booleanExpr_in_synpred1_Expr140);
        	booleanExpr();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,30,FOLLOW_30_in_synpred1_Expr142); if (state.failed) return ;
        	PushFollow(FOLLOW_booleanExpr_in_synpred1_Expr144);
        	booleanExpr();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,31,FOLLOW_31_in_synpred1_Expr146); if (state.failed) return ;
        	PushFollow(FOLLOW_booleanExpr_in_synpred1_Expr148);
        	booleanExpr();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred1_Expr"

    // Delegated rules

   	public bool synpred1_Expr() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred1_Expr_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_stat_in_prog53 = new BitSet(new ulong[]{0x0000000107080282UL});
    public static readonly BitSet FOLLOW_expr_in_stat65 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_SEPARATOR_in_stat67 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IDENT_in_stat79 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_stat81 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_expr_in_stat83 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_SEPARATOR_in_stat85 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_WS_in_stat100 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conditionalExpr_in_expr117 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_conditionalExpr140 = new BitSet(new ulong[]{0x0000000040000000UL});
    public static readonly BitSet FOLLOW_30_in_conditionalExpr142 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_conditionalExpr144 = new BitSet(new ulong[]{0x0000000080000000UL});
    public static readonly BitSet FOLLOW_31_in_conditionalExpr146 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_conditionalExpr148 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_conditionalExpr166 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_equalityExpr_in_booleanExpr177 = new BitSet(new ulong[]{0x0000000000000C02UL});
    public static readonly BitSet FOLLOW_AND_in_booleanExpr181 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_OR_in_booleanExpr186 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_equalityExpr_in_booleanExpr190 = new BitSet(new ulong[]{0x0000000000000C02UL});
    public static readonly BitSet FOLLOW_relationalExpr_in_equalityExpr204 = new BitSet(new ulong[]{0x0000000000003002UL});
    public static readonly BitSet FOLLOW_EQUALS_in_equalityExpr208 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_NOTEQUALS_in_equalityExpr213 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_relationalExpr_in_equalityExpr217 = new BitSet(new ulong[]{0x0000000000003002UL});
    public static readonly BitSet FOLLOW_addExpr_in_relationalExpr231 = new BitSet(new ulong[]{0x000000000003C002UL});
    public static readonly BitSet FOLLOW_LT_in_relationalExpr235 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_LTEQ_in_relationalExpr240 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_GT_in_relationalExpr245 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_GTEQ_in_relationalExpr250 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_addExpr_in_relationalExpr254 = new BitSet(new ulong[]{0x000000000003C002UL});
    public static readonly BitSet FOLLOW_multExpr_in_addExpr268 = new BitSet(new ulong[]{0x00000000000C0002UL});
    public static readonly BitSet FOLLOW_PLUS_in_addExpr272 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_MINUS_in_addExpr277 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_multExpr_in_addExpr281 = new BitSet(new ulong[]{0x00000000000C0002UL});
    public static readonly BitSet FOLLOW_powerExpr_in_multExpr295 = new BitSet(new ulong[]{0x0000000000700002UL});
    public static readonly BitSet FOLLOW_MULTIPLY_in_multExpr299 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_DIVIDE_in_multExpr304 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_MODULO_in_multExpr309 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_powerExpr_in_multExpr313 = new BitSet(new ulong[]{0x0000000000700002UL});
    public static readonly BitSet FOLLOW_unaryExpr_in_powerExpr327 = new BitSet(new ulong[]{0x0000000000800002UL});
    public static readonly BitSet FOLLOW_POWER_in_powerExpr330 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_unaryExpr_in_powerExpr333 = new BitSet(new ulong[]{0x0000000000800002UL});
    public static readonly BitSet FOLLOW_primaryExpr_in_unaryExpr347 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MINUS_in_unaryExpr352 = new BitSet(new ulong[]{0x0000000106000080UL});
    public static readonly BitSet FOLLOW_primaryExpr_in_unaryExpr354 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NOT_in_unaryExpr367 = new BitSet(new ulong[]{0x0000000106000080UL});
    public static readonly BitSet FOLLOW_primaryExpr_in_unaryExpr370 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_32_in_primaryExpr381 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_expr_in_primaryExpr384 = new BitSet(new ulong[]{0x0000000200000000UL});
    public static readonly BitSet FOLLOW_33_in_primaryExpr386 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_value_in_primaryExpr392 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_value0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_synpred1_Expr140 = new BitSet(new ulong[]{0x0000000040000000UL});
    public static readonly BitSet FOLLOW_30_in_synpred1_Expr142 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_synpred1_Expr144 = new BitSet(new ulong[]{0x0000000080000000UL});
    public static readonly BitSet FOLLOW_31_in_synpred1_Expr146 = new BitSet(new ulong[]{0x0000000107080080UL});
    public static readonly BitSet FOLLOW_booleanExpr_in_synpred1_Expr148 = new BitSet(new ulong[]{0x0000000000000002UL});

}
